package com.biomatch.utils;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

public class Pinyin4jUtil {
	public static String getPinYin(String hanzi) {  
              Hanyu hanyu = new Hanyu();
              // 中英文混合的一段文字
              String pinyin = null;
              if(hanzi!=null && hanzi!=""){
            	  
            	   String strPinyin = hanyu.getStringPinYin(hanzi);
            
            	   String strShortPinyin = hanyu.converterToFirstSpell(hanzi);
           
            	   pinyin = strShortPinyin + "_" + strPinyin;
            	   }
              return pinyin.length() < 50 ? pinyin : pinyin.substring(0, 49);
     }
             
}

class Hanyu
{
         private HanyuPinyinOutputFormat format = null;
         private String[] pinyin;       

         public Hanyu() 
         {
                   format = new HanyuPinyinOutputFormat();
                   format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
         }          

         //转换单个字符 
         public String getCharacterPinYin(char c) 
         { 
                   try
                   {
                            pinyin = PinyinHelper.toHanyuPinyinStringArray(c, format);
                   }
                   catch(BadHanyuPinyinOutputFormatCombination e)
                   {
                            e.printStackTrace();
                   }
                    
                   // 如果c不是汉字，toHanyuPinyinStringArray会返回null 
                   if(pinyin == null) return null;                   

                   // 只取一个发音，如果是多音字，仅取第一个发音 
                   return pinyin[0];    
         }
         
         //转换一个字符串 
         public String getStringPinYin(String str) 
         { 
                   StringBuilder sb = new StringBuilder(); 
                   String tempPinyin = null; 
                   for(int i = 0; i < str.length(); ++i) 
                   { 
                            tempPinyin =getCharacterPinYin(str.charAt(i)); 
                            if(tempPinyin == null) 
                            { 
                                     // 如果str.charAt(i)非汉字，则保持原样 
                                     sb.append(str.charAt(i)); 
                            } 
                            else 
                            { 
                                     sb.append(tempPinyin); 
                            } 
                   } 
                   return sb.toString(); 
         } 
         
         public String converterToFirstSpell(String chines) {  
             StringBuffer pinyinName = new StringBuffer();  
             char[] nameChar = chines.toCharArray();  
             HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
             defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
             defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
             for (int i = 0; i < nameChar.length; i++) {  
                 if (nameChar[i] > 128) {  
                     try {  
                         // 取得当前汉字的所有全拼  
                         String[] strs = PinyinHelper.toHanyuPinyinStringArray(  
                                 nameChar[i], defaultFormat);  
                         if (strs != null) {  
                             for (int j = 0; j < strs.length; j++) {  
                                 // 取首字母  
                                 pinyinName.append(strs[j].charAt(0));  
                                 if (j != strs.length - 1) {  
                                     pinyinName.append(",");  
                                 }  
                             }  
                         }  
                         // else {  
                         // pinyinName.append(nameChar[i]);  
                         // }  
                     } catch (BadHanyuPinyinOutputFormatCombination e) {  
                         e.printStackTrace();  
                     }  
                 } else {  
                     pinyinName.append(nameChar[i]);  
                 }  
                 pinyinName.append(" ");  
             }  
             // return pinyinName.toString();  
             return parseTheChineseByObject(discountTheChinese(pinyinName.toString()));  
         }  
         
         private static List<Map<String, Integer>> discountTheChinese(String theStr) {  
             // 去除重复拼音后的拼音列表  
             List<Map<String, Integer>> mapList = new ArrayList<Map<String, Integer>>();  
             // 用于处理每个字的多音字，去掉重复  
             Map<String, Integer> onlyOne = null;  
             String[] firsts = theStr.split(" ");  
             // 读出每个汉字的拼音  
             for (String str : firsts) {  
                 onlyOne = new Hashtable<String, Integer>();  
                 String[] china = str.split(",");  
                 // 多音字处理  
                 for (String s : china) {  
                     Integer count = onlyOne.get(s);  
                     if (count == null) {  
                         onlyOne.put(s, new Integer(1));  
                     } else {  
                         onlyOne.remove(s);  
                         count++;  
                         onlyOne.put(s, count);  
                     }  
                 }  
                 mapList.add(onlyOne);  
             }  
             return mapList;  
         }  
         
         private static String parseTheChineseByObject(  
                 List<Map<String, Integer>> list) {  
             Map<String, Integer> first = null; // 用于统计每一次,集合组合数据  
             // 遍历每一组集合  
             for (int i = 0; i < list.size(); i++) {  
                 // 每一组集合与上一次组合的Map  
                 Map<String, Integer> temp = new Hashtable<String, Integer>();  
                 // 第一次循环，first为空  
                 if (first != null) {  
                     // 取出上次组合与此次集合的字符，并保存  
                     for (String s : first.keySet()) {  
                         for (String s1 : list.get(i).keySet()) {  
                             String str = s + s1;  
                             temp.put(str, 1);  
                         }  
                     }  
                     // 清理上一次组合数据  
                     if (temp != null && temp.size() > 0) {  
                         first.clear();  
                     }  
                 } else {  
                     for (String s : list.get(i).keySet()) {  
                         String str = s;  
                         temp.put(str, 1);  
                     }  
                 }  
                 // 保存组合数据以便下次循环使用  
                 if (temp != null && temp.size() > 0) {  
                     first = temp;  
                 }  
             }  
             String returnStr = "";  
             if (first != null) {  
                 // 遍历取出组合字符串  
                 for (String str : first.keySet()) {  
                     returnStr += (str + "_");  
                 }  
             }  
             if (returnStr.length() > 0) {  
                 returnStr = returnStr.substring(0, returnStr.length() - 1);  
             }  
             return returnStr;  
         }  
}